/* 
 * File:   arbolint.cpp
 * Author: Administrador
 * 
 * Created on 5 de marzo de 2009, 12:00
 */

#include "arbolint.h"

ArbolInt::ArbolInt() {
    raizPtr = 0; // indica que al principio el árbol está vacío
}

ArbolInt::ArbolInt(const ArbolInt& orig) {
    // De momento no tenemos constructor de copias.
}

ArbolInt::~ArbolInt(){
   raizPtr->~NodoArbolInt(); //delete[]raizPtr;
}

void ArbolInt::insertarNodo( const int &valor )
{
    ayudanteInsertarNodo( &raizPtr, valor );
} // fin de la función insertarNodo

void ArbolInt::ayudanteInsertarNodo(
   NodoArbolInt **ptr, const int &valor )
{
   // el subárbol está vacío; crea nuevo NodoArbol que contiene el valor
   if ( *ptr == 0 )
      *ptr = new NodoArbolInt( valor );
   else // el subárbol no está vacío
   {
      // los datos a insertar son menores que los datos en el nodo actual
      if ( valor < ( *ptr )->datos )
         ayudanteInsertarNodo( &( ( *ptr )->izquierdoPtr ), valor );
      else
      {
         // los datos a insertar son mayores que los datos en el nodo actual
         if ( valor > ( *ptr )->datos )
            ayudanteInsertarNodo( &( ( *ptr )->derechoPtr ), valor );
         else // se ignora el valor de datos duplicado
            cout << valor << " dup" << endl;
      } // fin de else
   } // fin de else
} // fin de la función ayudanteInsertarNodo

void ArbolInt::recorridoPreOrden() const
{
   ayudantePreOrden( raizPtr );
} // fin de la función recorridoPreOrden

void ArbolInt::ayudantePreOrden( NodoArbolInt *ptr ) const
{
   if ( ptr != 0 )
   {
      cout << ptr->datos << ' '; // procesa el nodo
      ayudantePreOrden( ptr->izquierdoPtr ); // recorre el subárbol izquierdo
      ayudantePreOrden( ptr->derechoPtr ); // recorre el subárbol derecho
   } // fin de if
} // fin de la función ayudantePreOrden

void ArbolInt::recorridoInOrden(ostringstream &recorrido) const
{
   ayudanteInOrden( raizPtr, recorrido );
} // fin de la función recorridoInOrden

void ArbolInt::ayudanteInOrden( NodoArbolInt *ptr, ostringstream &recorrido ) const
{
   if ( ptr != 0 )
   {
      ayudanteInOrden( ptr->izquierdoPtr, recorrido ); // recorre el subárbol izquierdo
      recorrido << ptr->datos << ' '; // procesa el nodo
      ayudanteInOrden( ptr->derechoPtr, recorrido ); // recorre el subárbol derecho
   } // fin de if
} // fin de la función ayudanteInOrden

void ArbolInt::recorridoPostOrden() const
{
   ayudantePostOrden( raizPtr );
} // fin de la función recorridoPostOrden

void ArbolInt::ayudantePostOrden(
   NodoArbolInt *ptr ) const
{
   if ( ptr != 0 )
   {
      ayudantePostOrden( ptr->izquierdoPtr ); // recorre el subárbol izquierdo
      ayudantePostOrden( ptr->derechoPtr ); // recorre el subárbol derecho
      cout << ptr->datos << ' '; // procesa el nodo
   } // fin de if
} // fin de la función ayudantePostOrden

bool ArbolInt::buscar (const int &numbq){
    bool encontrado = buscarAyudante (raizPtr, numbq);
    return encontrado;
}

bool ArbolInt::buscarAyudante( NodoArbolInt *ptr, const int &numbq){
    bool encontrado = false;
    if (ptr != 0){
        if (ptr->datos == numbq){
            encontrado = true;
        }
        else if (numbq < ptr->datos){
            encontrado = buscarAyudante (ptr->izquierdoPtr, numbq);
        }
        else {
            encontrado = buscarAyudante (ptr->derechoPtr, numbq);
        }
    }
    return encontrado;
}

/*
bool ArbolInt::buscar (const int &numbq){
    NodoArbolInt *iter = raizPtr;
 *  bool encontrado = false;
 *  while ((!encontrado) && (iter!=0)){
 *    if (iter->datos = numbq )
 *        encontrado = true;
 *    else if (iter->datos < numbq)
 *             iter = iter->derechoPtr;
 *         else iter = iter->izquierdoPtr;
 *  }
    return encontrado;
}
 * */
